home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / javax / imageio / ImageIO.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  12.3 KB  |  659 lines
  1. package javax.imageio;
  2.  
  3. import java.awt.image.BufferedImage;
  4. import java.awt.image.RenderedImage;
  5. import java.io.File;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.OutputStream;
  9. import java.lang.reflect.Method;
  10. import java.net.URL;
  11. import java.security.AccessController;
  12. import java.util.Collections;
  13. import java.util.HashSet;
  14. import java.util.Iterator;
  15. import javax.imageio.spi.IIORegistry;
  16. import javax.imageio.spi.ImageInputStreamSpi;
  17. import javax.imageio.spi.ImageOutputStreamSpi;
  18. import javax.imageio.spi.ImageReaderSpi;
  19. import javax.imageio.spi.ImageReaderWriterSpi;
  20. import javax.imageio.spi.ImageTranscoderSpi;
  21. import javax.imageio.spi.ImageWriterSpi;
  22. import javax.imageio.stream.ImageInputStream;
  23. import javax.imageio.stream.ImageOutputStream;
  24. import sun.awt.AppContext;
  25. import sun.security.action.GetPropertyAction;
  26.  
  27. public final class ImageIO {
  28.    private static final IIORegistry theRegistry = IIORegistry.getDefaultInstance();
  29.    private static Method readerFormatNamesMethod;
  30.    private static Method readerFileSuffixesMethod;
  31.    private static Method readerMIMETypesMethod;
  32.    private static Method writerFormatNamesMethod;
  33.    private static Method writerFileSuffixesMethod;
  34.    private static Method writerMIMETypesMethod;
  35.  
  36.    private ImageIO() {
  37.    }
  38.  
  39.    public static void scanForPlugins() {
  40.       theRegistry.registerApplicationClasspathSpis();
  41.    }
  42.  
  43.    private static synchronized CacheInfo getCacheInfo() {
  44.       AppContext var0 = AppContext.getAppContext();
  45.       CacheInfo var1 = (CacheInfo)var0.get(CacheInfo.class);
  46.       if (var1 == null) {
  47.          var1 = new CacheInfo();
  48.          var0.put(CacheInfo.class, var1);
  49.       }
  50.  
  51.       return var1;
  52.    }
  53.  
  54.    private static String getTempDir() {
  55.       GetPropertyAction var0 = new GetPropertyAction("java.io.tmpdir");
  56.       return (String)AccessController.doPrivileged(var0);
  57.    }
  58.  
  59.    private static boolean hasCachePermission() {
  60.       Boolean var0 = getCacheInfo().getHasPermission();
  61.       if (var0 != null) {
  62.          return var0;
  63.       } else {
  64.          try {
  65.             SecurityManager var1 = System.getSecurityManager();
  66.             if (var1 != null) {
  67.                File var2 = getCacheDirectory();
  68.                String var3;
  69.                if (var2 != null) {
  70.                   var3 = var2.getPath();
  71.                } else {
  72.                   var3 = getTempDir();
  73.                   if (var3 == null) {
  74.                      getCacheInfo().setHasPermission(Boolean.FALSE);
  75.                      return false;
  76.                   }
  77.                }
  78.  
  79.                var1.checkWrite(var3);
  80.             }
  81.          } catch (SecurityException var4) {
  82.             getCacheInfo().setHasPermission(Boolean.FALSE);
  83.             return false;
  84.          }
  85.  
  86.          getCacheInfo().setHasPermission(Boolean.TRUE);
  87.          return true;
  88.       }
  89.    }
  90.  
  91.    public static void setUseCache(boolean var0) {
  92.       getCacheInfo().setUseCache(var0);
  93.    }
  94.  
  95.    public static boolean getUseCache() {
  96.       return getCacheInfo().getUseCache();
  97.    }
  98.  
  99.    public static void setCacheDirectory(File var0) {
  100.       if (var0 != null && !var0.isDirectory()) {
  101.          throw new IllegalArgumentException("Not a directory!");
  102.       } else {
  103.          getCacheInfo().setCacheDirectory(var0);
  104.          getCacheInfo().setHasPermission((Boolean)null);
  105.       }
  106.    }
  107.  
  108.    public static File getCacheDirectory() {
  109.       return getCacheInfo().getCacheDirectory();
  110.    }
  111.  
  112.    public static ImageInputStream createImageInputStream(Object var0) throws IOException {
  113.       if (var0 == null) {
  114.          throw new IllegalArgumentException("input == null!");
  115.       } else {
  116.          Iterator var1;
  117.          try {
  118.             var1 = theRegistry.getServiceProviders(ImageInputStreamSpi.class, true);
  119.          } catch (IllegalArgumentException var6) {
  120.             return null;
  121.          }
  122.  
  123.          boolean var2 = getUseCache() && hasCachePermission();
  124.  
  125.          while(var1.hasNext()) {
  126.             ImageInputStreamSpi var3 = (ImageInputStreamSpi)var1.next();
  127.             if (var3.getInputClass().isInstance(var0)) {
  128.                try {
  129.                   return var3.createInputStreamInstance(var0, var2, getCacheDirectory());
  130.                } catch (IOException var5) {
  131.                   throw new IIOException("Can't create cache file!", var5);
  132.                }
  133.             }
  134.          }
  135.  
  136.          return null;
  137.       }
  138.    }
  139.  
  140.    public static ImageOutputStream createImageOutputStream(Object var0) throws IOException {
  141.       if (var0 == null) {
  142.          throw new IllegalArgumentException("output == null!");
  143.       } else {
  144.          Iterator var1;
  145.          try {
  146.             var1 = theRegistry.getServiceProviders(ImageOutputStreamSpi.class, true);
  147.          } catch (IllegalArgumentException var6) {
  148.             return null;
  149.          }
  150.  
  151.          boolean var2 = getUseCache() && hasCachePermission();
  152.  
  153.          while(var1.hasNext()) {
  154.             ImageOutputStreamSpi var3 = (ImageOutputStreamSpi)var1.next();
  155.             if (var3.getOutputClass().isInstance(var0)) {
  156.                try {
  157.                   return var3.createOutputStreamInstance(var0, var2, getCacheDirectory());
  158.                } catch (IOException var5) {
  159.                   throw new IIOException("Can't create cache file!", var5);
  160.                }
  161.             }
  162.          }
  163.  
  164.          return null;
  165.       }
  166.    }
  167.  
  168.    private static <S extends ImageReaderWriterSpi> String[] getReaderWriterInfo(Class<S> var0, SpiInfo var1) {
  169.       Iterator var2;
  170.       try {
  171.          var2 = theRegistry.getServiceProviders(var0, true);
  172.       } catch (IllegalArgumentException var5) {
  173.          return new String[0];
  174.       }
  175.  
  176.       HashSet var3 = new HashSet();
  177.  
  178.       while(var2.hasNext()) {
  179.          ImageReaderWriterSpi var4 = (ImageReaderWriterSpi)var2.next();
  180.          Collections.addAll(var3, var1.info(var4));
  181.       }
  182.  
  183.       return (String[])var3.toArray(new String[var3.size()]);
  184.    }
  185.  
  186.    public static String[] getReaderFormatNames() {
  187.       return getReaderWriterInfo(ImageReaderSpi.class, javax.imageio.ImageIO.SpiInfo.FORMAT_NAMES);
  188.    }
  189.  
  190.    public static String[] getReaderMIMETypes() {
  191.       return getReaderWriterInfo(ImageReaderSpi.class, javax.imageio.ImageIO.SpiInfo.MIME_TYPES);
  192.    }
  193.  
  194.    public static String[] getReaderFileSuffixes() {
  195.       return getReaderWriterInfo(ImageReaderSpi.class, javax.imageio.ImageIO.SpiInfo.FILE_SUFFIXES);
  196.    }
  197.  
  198.    public static Iterator<ImageReader> getImageReaders(Object var0) {
  199.       if (var0 == null) {
  200.          throw new IllegalArgumentException("input == null!");
  201.       } else {
  202.          Iterator var1;
  203.          try {
  204.             var1 = theRegistry.getServiceProviders(ImageReaderSpi.class, new CanDecodeInputFilter(var0), true);
  205.          } catch (IllegalArgumentException var3) {
  206.             return (new HashSet()).iterator();
  207.          }
  208.  
  209.          return new ImageReaderIterator(var1);
  210.       }
  211.    }
  212.  
  213.    public static Iterator<ImageReader> getImageReadersByFormatName(String var0) {
  214.       if (var0 == null) {
  215.          throw new IllegalArgumentException("formatName == null!");
  216.       } else {
  217.          Iterator var1;
  218.          try {
  219.             var1 = theRegistry.getServiceProviders(ImageReaderSpi.class, new ContainsFilter(readerFormatNamesMethod, var0), true);
  220.          } catch (IllegalArgumentException var3) {
  221.             return (new HashSet()).iterator();
  222.          }
  223.  
  224.          return new ImageReaderIterator(var1);
  225.       }
  226.    }
  227.  
  228.    public static Iterator<ImageReader> getImageReadersBySuffix(String var0) {
  229.       if (var0 == null) {
  230.          throw new IllegalArgumentException("fileSuffix == null!");
  231.       } else {
  232.          Iterator var1;
  233.          try {
  234.             var1 = theRegistry.getServiceProviders(ImageReaderSpi.class, new ContainsFilter(readerFileSuffixesMethod, var0), true);
  235.          } catch (IllegalArgumentException var3) {
  236.             return (new HashSet()).iterator();
  237.          }
  238.  
  239.          return new ImageReaderIterator(var1);
  240.       }
  241.    }
  242.  
  243.    public static Iterator<ImageReader> getImageReadersByMIMEType(String var0) {
  244.       if (var0 == null) {
  245.          throw new IllegalArgumentException("MIMEType == null!");
  246.       } else {
  247.          Iterator var1;
  248.          try {
  249.             var1 = theRegistry.getServiceProviders(ImageReaderSpi.class, new ContainsFilter(readerMIMETypesMethod, var0), true);
  250.          } catch (IllegalArgumentException var3) {
  251.             return (new HashSet()).iterator();
  252.          }
  253.  
  254.          return new ImageReaderIterator(var1);
  255.       }
  256.    }
  257.  
  258.    public static String[] getWriterFormatNames() {
  259.       return getReaderWriterInfo(ImageWriterSpi.class, javax.imageio.ImageIO.SpiInfo.FORMAT_NAMES);
  260.    }
  261.  
  262.    public static String[] getWriterMIMETypes() {
  263.       return getReaderWriterInfo(ImageWriterSpi.class, javax.imageio.ImageIO.SpiInfo.MIME_TYPES);
  264.    }
  265.  
  266.    public static String[] getWriterFileSuffixes() {
  267.       return getReaderWriterInfo(ImageWriterSpi.class, javax.imageio.ImageIO.SpiInfo.FILE_SUFFIXES);
  268.    }
  269.  
  270.    private static boolean contains(String[] var0, String var1) {
  271.       for(int var2 = 0; var2 < var0.length; ++var2) {
  272.          if (var1.equalsIgnoreCase(var0[var2])) {
  273.             return true;
  274.          }
  275.       }
  276.  
  277.       return false;
  278.    }
  279.  
  280.    public static Iterator<ImageWriter> getImageWritersByFormatName(String var0) {
  281.       if (var0 == null) {
  282.          throw new IllegalArgumentException("formatName == null!");
  283.       } else {
  284.          Iterator var1;
  285.          try {
  286.             var1 = theRegistry.getServiceProviders(ImageWriterSpi.class, new ContainsFilter(writerFormatNamesMethod, var0), true);
  287.          } catch (IllegalArgumentException var3) {
  288.             return (new HashSet()).iterator();
  289.          }
  290.  
  291.          return new ImageWriterIterator(var1);
  292.       }
  293.    }
  294.  
  295.    public static Iterator<ImageWriter> getImageWritersBySuffix(String var0) {
  296.       if (var0 == null) {
  297.          throw new IllegalArgumentException("fileSuffix == null!");
  298.       } else {
  299.          Iterator var1;
  300.          try {
  301.             var1 = theRegistry.getServiceProviders(ImageWriterSpi.class, new ContainsFilter(writerFileSuffixesMethod, var0), true);
  302.          } catch (IllegalArgumentException var3) {
  303.             return (new HashSet()).iterator();
  304.          }
  305.  
  306.          return new ImageWriterIterator(var1);
  307.       }
  308.    }
  309.  
  310.    public static Iterator<ImageWriter> getImageWritersByMIMEType(String var0) {
  311.       if (var0 == null) {
  312.          throw new IllegalArgumentException("MIMEType == null!");
  313.       } else {
  314.          Iterator var1;
  315.          try {
  316.             var1 = theRegistry.getServiceProviders(ImageWriterSpi.class, new ContainsFilter(writerMIMETypesMethod, var0), true);
  317.          } catch (IllegalArgumentException var3) {
  318.             return (new HashSet()).iterator();
  319.          }
  320.  
  321.          return new ImageWriterIterator(var1);
  322.       }
  323.    }
  324.  
  325.    public static ImageWriter getImageWriter(ImageReader var0) {
  326.       if (var0 == null) {
  327.          throw new IllegalArgumentException("reader == null!");
  328.       } else {
  329.          ImageReaderSpi var1 = var0.getOriginatingProvider();
  330.          if (var1 == null) {
  331.             Iterator var2;
  332.             try {
  333.                var2 = theRegistry.getServiceProviders(ImageReaderSpi.class, false);
  334.             } catch (IllegalArgumentException var8) {
  335.                return null;
  336.             }
  337.  
  338.             while(var2.hasNext()) {
  339.                ImageReaderSpi var3 = (ImageReaderSpi)var2.next();
  340.                if (var3.isOwnReader(var0)) {
  341.                   var1 = var3;
  342.                   break;
  343.                }
  344.             }
  345.  
  346.             if (var1 == null) {
  347.                return null;
  348.             }
  349.          }
  350.  
  351.          String[] var9 = var1.getImageWriterSpiNames();
  352.          if (var9 == null) {
  353.             return null;
  354.          } else {
  355.             Object var10 = null;
  356.  
  357.             try {
  358.                var11 = Class.forName(var9[0], true, ClassLoader.getSystemClassLoader());
  359.             } catch (ClassNotFoundException var7) {
  360.                return null;
  361.             }
  362.  
  363.             ImageWriterSpi var4 = (ImageWriterSpi)theRegistry.getServiceProviderByClass(var11);
  364.             if (var4 == null) {
  365.                return null;
  366.             } else {
  367.                try {
  368.                   return var4.createWriterInstance();
  369.                } catch (IOException var6) {
  370.                   theRegistry.deregisterServiceProvider(var4, ImageWriterSpi.class);
  371.                   return null;
  372.                }
  373.             }
  374.          }
  375.       }
  376.    }
  377.  
  378.    public static ImageReader getImageReader(ImageWriter var0) {
  379.       if (var0 == null) {
  380.          throw new IllegalArgumentException("writer == null!");
  381.       } else {
  382.          ImageWriterSpi var1 = var0.getOriginatingProvider();
  383.          if (var1 == null) {
  384.             Iterator var2;
  385.             try {
  386.                var2 = theRegistry.getServiceProviders(ImageWriterSpi.class, false);
  387.             } catch (IllegalArgumentException var8) {
  388.                return null;
  389.             }
  390.  
  391.             while(var2.hasNext()) {
  392.                ImageWriterSpi var3 = (ImageWriterSpi)var2.next();
  393.                if (var3.isOwnWriter(var0)) {
  394.                   var1 = var3;
  395.                   break;
  396.                }
  397.             }
  398.  
  399.             if (var1 == null) {
  400.                return null;
  401.             }
  402.          }
  403.  
  404.          String[] var9 = var1.getImageReaderSpiNames();
  405.          if (var9 == null) {
  406.             return null;
  407.          } else {
  408.             Object var10 = null;
  409.  
  410.             try {
  411.                var11 = Class.forName(var9[0], true, ClassLoader.getSystemClassLoader());
  412.             } catch (ClassNotFoundException var7) {
  413.                return null;
  414.             }
  415.  
  416.             ImageReaderSpi var4 = (ImageReaderSpi)theRegistry.getServiceProviderByClass(var11);
  417.             if (var4 == null) {
  418.                return null;
  419.             } else {
  420.                try {
  421.                   return var4.createReaderInstance();
  422.                } catch (IOException var6) {
  423.                   theRegistry.deregisterServiceProvider(var4, ImageReaderSpi.class);
  424.                   return null;
  425.                }
  426.             }
  427.          }
  428.       }
  429.    }
  430.  
  431.    public static Iterator<ImageWriter> getImageWriters(ImageTypeSpecifier var0, String var1) {
  432.       if (var0 == null) {
  433.          throw new IllegalArgumentException("type == null!");
  434.       } else if (var1 == null) {
  435.          throw new IllegalArgumentException("formatName == null!");
  436.       } else {
  437.          Iterator var2;
  438.          try {
  439.             var2 = theRegistry.getServiceProviders(ImageWriterSpi.class, new CanEncodeImageAndFormatFilter(var0, var1), true);
  440.          } catch (IllegalArgumentException var4) {
  441.             return (new HashSet()).iterator();
  442.          }
  443.  
  444.          return new ImageWriterIterator(var2);
  445.       }
  446.    }
  447.  
  448.    public static Iterator<ImageTranscoder> getImageTranscoders(ImageReader var0, ImageWriter var1) {
  449.       if (var0 == null) {
  450.          throw new IllegalArgumentException("reader == null!");
  451.       } else if (var1 == null) {
  452.          throw new IllegalArgumentException("writer == null!");
  453.       } else {
  454.          ImageReaderSpi var2 = var0.getOriginatingProvider();
  455.          ImageWriterSpi var3 = var1.getOriginatingProvider();
  456.          TranscoderFilter var4 = new TranscoderFilter(var2, var3);
  457.  
  458.          Iterator var5;
  459.          try {
  460.             var5 = theRegistry.getServiceProviders(ImageTranscoderSpi.class, var4, true);
  461.          } catch (IllegalArgumentException var7) {
  462.             return (new HashSet()).iterator();
  463.          }
  464.  
  465.          return new ImageTranscoderIterator(var5);
  466.       }
  467.    }
  468.  
  469.    public static BufferedImage read(File var0) throws IOException {
  470.       if (var0 == null) {
  471.          throw new IllegalArgumentException("input == null!");
  472.       } else if (!var0.canRead()) {
  473.          throw new IIOException("Can't read input file!");
  474.       } else {
  475.          ImageInputStream var1 = createImageInputStream(var0);
  476.          if (var1 == null) {
  477.             throw new IIOException("Can't create an ImageInputStream!");
  478.          } else {
  479.             BufferedImage var2 = read(var1);
  480.             if (var2 == null) {
  481.                var1.close();
  482.             }
  483.  
  484.             return var2;
  485.          }
  486.       }
  487.    }
  488.  
  489.    public static BufferedImage read(InputStream var0) throws IOException {
  490.       if (var0 == null) {
  491.          throw new IllegalArgumentException("input == null!");
  492.       } else {
  493.          ImageInputStream var1 = createImageInputStream(var0);
  494.          BufferedImage var2 = read(var1);
  495.          if (var2 == null) {
  496.             var1.close();
  497.          }
  498.  
  499.          return var2;
  500.       }
  501.    }
  502.  
  503.    public static BufferedImage read(URL var0) throws IOException {
  504.       if (var0 == null) {
  505.          throw new IllegalArgumentException("input == null!");
  506.       } else {
  507.          Object var1 = null;
  508.  
  509.          try {
  510.             var9 = var0.openStream();
  511.          } catch (IOException var7) {
  512.             throw new IIOException("Can't get input stream from URL!", var7);
  513.          }
  514.  
  515.          ImageInputStream var2 = createImageInputStream(var9);
  516.  
  517.          BufferedImage var3;
  518.          try {
  519.             var3 = read(var2);
  520.             if (var3 == null) {
  521.                var2.close();
  522.             }
  523.          } finally {
  524.             var9.close();
  525.          }
  526.  
  527.          return var3;
  528.       }
  529.    }
  530.  
  531.    public static BufferedImage read(ImageInputStream var0) throws IOException {
  532.       if (var0 == null) {
  533.          throw new IllegalArgumentException("stream == null!");
  534.       } else {
  535.          Iterator var1 = getImageReaders(var0);
  536.          if (!var1.hasNext()) {
  537.             return null;
  538.          } else {
  539.             ImageReader var2 = (ImageReader)var1.next();
  540.             ImageReadParam var3 = var2.getDefaultReadParam();
  541.             var2.setInput(var0, true, true);
  542.  
  543.             BufferedImage var4;
  544.             try {
  545.                var4 = var2.read(0, var3);
  546.             } finally {
  547.                var2.dispose();
  548.                var0.close();
  549.             }
  550.  
  551.             return var4;
  552.          }
  553.       }
  554.    }
  555.  
  556.    public static boolean write(RenderedImage var0, String var1, ImageOutputStream var2) throws IOException {
  557.       if (var0 == null) {
  558.          throw new IllegalArgumentException("im == null!");
  559.       } else if (var1 == null) {
  560.          throw new IllegalArgumentException("formatName == null!");
  561.       } else if (var2 == null) {
  562.          throw new IllegalArgumentException("output == null!");
  563.       } else {
  564.          ImageWriter var3 = null;
  565.          ImageTypeSpecifier var4 = ImageTypeSpecifier.createFromRenderedImage(var0);
  566.          Iterator var5 = getImageWriters(var4, var1);
  567.          if (var5.hasNext()) {
  568.             var3 = (ImageWriter)var5.next();
  569.          }
  570.  
  571.          if (var3 == null) {
  572.             return false;
  573.          } else {
  574.             var3.setOutput(var2);
  575.  
  576.             try {
  577.                var3.write(var0);
  578.             } finally {
  579.                var3.dispose();
  580.                var2.flush();
  581.             }
  582.  
  583.             return true;
  584.          }
  585.       }
  586.    }
  587.  
  588.    public static boolean write(RenderedImage var0, String var1, File var2) throws IOException {
  589.       if (var2 == null) {
  590.          throw new IllegalArgumentException("output == null!");
  591.       } else {
  592.          Object var3 = null;
  593.  
  594.          try {
  595.             var2.delete();
  596.             var10 = createImageOutputStream(var2);
  597.          } catch (IOException var9) {
  598.             throw new IIOException("Can't create output stream!", var9);
  599.          }
  600.  
  601.          boolean var4;
  602.          try {
  603.             var4 = write(var0, var1, var10);
  604.          } finally {
  605.             var10.close();
  606.          }
  607.  
  608.          return var4;
  609.       }
  610.    }
  611.  
  612.    public static boolean write(RenderedImage var0, String var1, OutputStream var2) throws IOException {
  613.       if (var2 == null) {
  614.          throw new IllegalArgumentException("output == null!");
  615.       } else {
  616.          Object var3 = null;
  617.  
  618.          try {
  619.             var10 = createImageOutputStream(var2);
  620.          } catch (IOException var9) {
  621.             throw new IIOException("Can't create output stream!", var9);
  622.          }
  623.  
  624.          boolean var4;
  625.          try {
  626.             var4 = write(var0, var1, var10);
  627.          } finally {
  628.             var10.close();
  629.          }
  630.  
  631.          return var4;
  632.       }
  633.    }
  634.  
  635.    // $FF: synthetic method
  636.    static IIORegistry access$100() {
  637.       return theRegistry;
  638.    }
  639.  
  640.    // $FF: synthetic method
  641.    static boolean access$200(String[] var0, String var1) {
  642.       return contains(var0, var1);
  643.    }
  644.  
  645.    static {
  646.       try {
  647.          readerFormatNamesMethod = ImageReaderSpi.class.getMethod("getFormatNames");
  648.          readerFileSuffixesMethod = ImageReaderSpi.class.getMethod("getFileSuffixes");
  649.          readerMIMETypesMethod = ImageReaderSpi.class.getMethod("getMIMETypes");
  650.          writerFormatNamesMethod = ImageWriterSpi.class.getMethod("getFormatNames");
  651.          writerFileSuffixesMethod = ImageWriterSpi.class.getMethod("getFileSuffixes");
  652.          writerMIMETypesMethod = ImageWriterSpi.class.getMethod("getMIMETypes");
  653.       } catch (NoSuchMethodException var1) {
  654.          var1.printStackTrace();
  655.       }
  656.  
  657.    }
  658. }
  659.